Understanding the performance of interactive applications

Many if not most computer systems are used by human users. The performance of such interactive systems ultimately affects those users. Thus, when measuring, understanding, and improving system performance, it makes sense to consider the human user's perspective. Essentially, the performance of interactive applications is determined by the perceptible lag in handling user requests. So, when characterizing the runtime of an interactive application we need a new approach that focuses on the perceptible lags rather than on overall and general performance characteristics. Such a new characterization approach should enable a new way to profile and improve the performance of interactive applications. Imagine a way that would seek out these perceptible lags and then investigate the causes of these lags. Performance analysts could simply optimize responsible parts of the software, thus eliminating perceptible lag for interactive applications. Unfortunately, existing profiling approaches either incur significant overhead that makes them impractical for an interactive scenario, or they lack the ability to provide insight into the causes of long latencies. An effective approach for interactive applications has to fulfill several requirements such as an accurate view of the causes of performance problems and insignificant perturbation of the interactive application. We propose a new profiling approach that helps developers to understand and improve the perceptible performance of interactive applications and satisfies the above needs

Automated GUI performance testing

A significant body of prior work has devised approaches for automating the functional testing of interactive applications. However, little work exists for automatically testing their performance. Performance testing imposes additional requirements upon GUI test automation tools: the tools have to be able to replay complex interactive sessions, and they have to avoid perturbing the application's performance. We study the feasibility of using five Java GUI capture and replay tools for GUI performance test automation. Besides confirming the severity of the previously known GUI element identification problem, we also describe a related problem, the temporal synchronization problem, which is of increasing importance for GUI applications that use timer-driven activity. We find that most of the tools we study have severe limitations when used for recording and replaying realistic sessions of real-world Java applications and that all of them suffer from the temporal synchronization problem. However, we find that the most reliable tool, Pounder, causes only limited perturbation and thus can be used to automate performance testing. Based on an investigation of Pounder's approach, we further improve its robustness and reduce its perturbation. Finally, we demonstrate in a set of case studies that the conclusions about perceptible performance drawn from manual tests still hold when using automated tests driven by Pounder. Besides the significance of our findings to GUI performance testing, the results are also relevant to capture and replay-based functional GUI test automation approache

When and how java developers give up static type safety

The main goal of a static type system is to prevent certain kinds of errors from happening at run time. A type system is formulated as a set of constraints that gives any expression or term in a program a well-defined type. Besides detecting these kinds of errors, a static type system can be an invaluable maintenance tool, can be useful for documentation purposes, and can aid in generating more efficient machine code. However, there are situations when the developer has more information about the program that is too complex to explain in terms of typing constraints. To that end, programming languages often provide mechanisms that make the typing constraints less strict to permit more programs to be valid, at the expense of causing more errors at run time. These mechanisms are essentially two: Unsafe Intrinsics and Reflective Capabilities. We want to understand how and when developers give up these static constraints. This knowledge can be useful as: a) a recommendation for current and future language designers to make informed decisions, b) a reference for tool builders, e.g., by providing more precise or new refactoring analyses, c) a guide for researchers to test new language features, or to carry out controlled programming experiments, and d) a guide for developers for better practices. In this dissertation, we focus on the Unsafe API and cast operator---a subset of unsafe intrinsics and reflective capabilities respectively---in Java. We report two empirical studies to understand how these mechanisms---Unsafe API and cast operator---are used by Java developers when the static type system becomes too strict. We have devised usage patterns for both the Unsafe API and cast operator. Usage patterns are recurrent programming idioms to solve a specific issue. We believe that having usage patterns can help us to better categorize use cases and thus understand how those features are used

The implementation of physicians assistant in a surgical ward improves continuity in daily clinical work and increases comprehensibility of nurses and physicians

INTRODUCTION Physician Assistant (PA) have been deployed to increase the capacity of a team, supporting continuity and medical cover. The goal of this study was to assess the implementation of PAs on continuity of surgical rounds, on the collaboration of nurses and physicians and on support of administrative work. METHODS This cross-sectional survey was performed on nurses and physicians who work full-time at a surgical ward in a Swiss reference center. PAs were introduced in our institution in 2019. Participants answered a self-developed questionnaire 6 and 12 months after the implementation of PAs. Administrative work, teamwork, improvement of workflow, and training of physicians has been assessed. Participants answered questions on a 5-point Likert scale and were stratified according to profession (nurse, physician). RESULTS Participants (n = 53) reported a positive effect on the regular conduct of rounds (2.9, SD 1.1 points after 6 weeks and 3.5, SD 1.1 points after 12 weeks, p = 0.05). A significant improvement of nurse-doctor collaboration has been reported (3.6, SD 1.0 and 4.2, SD 0.8, p = 0.05). Nurses (n = 28, 52.8%) reported the that PAs are integrated in the physicians team rather than the nurses team (4.0, SD 0.0 points and 4.4, SD 0.7 points, p = 0.266) and a significant beneficial effect on the surgical clinic (3.7, SD 1.0 points and 4.4, SD 0.8 points, p = 0.043). Improved overall management of surgical cases was reported by the physicians (n = 25, 47.2%) (4.8, SD 0.4 and 4.3, SD 0.6, p = 0.046). CONCLUSION The implementation of PA has improved the collaboration of physicians and nurses substantially. Continuity of rounds has improved and the administrative workload for residents decreased substantially. Overall, the implementation of PA was reported to be beneficial for the surgical clinic

High-level real-time programming in Java

Real-time systems have reached a level of complexity beyond the scaling capability of the low-level or restricted languages traditionally used for real-time programming. While Metronome garbage collection has made it practical to use Java to implement real-time systems, many challenges remain for the construction of complex real-time systems, some specic to the use of Java and others simply due to the change in scale of such systems. The goal of our research is the creation of a comprehensive Java-based programming environment and methodology for the creation of complex real-time systems. Our goals include construction of a provably correct real-time garbage collec-tor capable of providing worst case latencies of 100 s, capa-ble of scaling from sensor nodes up to large multiprocessors; specialized programming constructs that retain the safety and simplicity of Java, and yet provide sub-microsecond la-tencies; the extension of Java's \write once, run anywhere" principle from functional correctness to timing behavior; on-line analysis and visualization that aids in the understanding of complex behaviors; and a principled probabilistic analy-sis methodology for bounding the behavior of the resulting systems. While much remains to be done, this paper describes the progress we have made towards these goals

The Truth, the Whole Truth, and Nothing but the Truth: A Pragmatic Guide to Assessing Empirical Evaluations

An unsound claim can misdirect a field, encouraging the pursuit of unworthy ideas and the abandonment of promising ideas. An inadequate description of a claim can make it difficult to reason about the claim, for example to determine whether the claim is sound. Many practitioners will acknowledge the threat of un- sound claims or inadequate descriptions of claims to their field. We believe that this situation is exacerbated and even encouraged by the lack of a systematic approach to exploring, exposing, and addressing the source of unsound claims and poor exposition. This paper proposes a framework that identifies three sins of reasoning that lead to unsound claims and two sins of exposition that lead to poorly described claims. Sins of exposition obfuscate the objective of determining whether or not a claim is sound, while sins of reasoning lead directly to unsound claims. Our framework provides practitioners with a principled way of critiquing the integrity of their own work and the work of others. We hope that this will help individuals conduct better science and encourage a cultural shift in our research community to identify and promulgate sound claims

Efficient Transduction of Vascular Endothelial Cells with Recombinant Adeno-Associated Virus Serotype 1 and 5 Vectors

Recombinant adeno-associated virus (rAAV) has become an attractive tool for gene therapy because of its ability to transduce both dividing and nondividing cells, elicit a limited immune response, and the capacity for imparting long-term transgene expression. Previous studies have utilized rAAV serotype 2 predominantly and found that transduction of vascular cells is relatively inefficient. The purpose of the present study was to evaluate the transduction efficiency of rAAV serotypes 1 through 5 in human and rat aortic endothelial cells (HAEC and RAEC). rAAV vectors with AAV2 inverted terminal repeats containing the human α1-antitrypsin (hAAT) gene were transcapsidated using helper plasmids to provide viral capsids for the AAV1 through 5 serotypes. True type rAAV2 and 5 vectors encoding β-galactosidase or green fluorescence protein were also studied. Infection with rAAV1 resulted in the most efficient transduction in both HAEC and RAEC compared to other serotypes (p < 0.001) at 7 days posttransduction. Interestingly, expression was increased in cells transduced with rAAV5 to levels surpassing rAAV1 by day 14 and 21. Transduction with rAAV1 was completely inhibited by removal of sialic acid with sialidase, while heparin had no effect. These studies are the first demonstration that sialic acid residues are required for rAAV1 transduction in endothelial cells. Transduction of rat aortic segments ex vivo and in vivo demonstrated significant transgene expression in endothelial and smooth muscle cells with rAAV1 and 5 serotype vectors, in comparison to rAAV2. These results suggest the unique potential of rAAV1 and rAAV5-based vectors for vascular-targeted gene-based therapeutic strategies

Accuracy of performance counter measurements

Many workload characterization studies depend on accurate measurements of the cost of executing a piece of code. Often these measurements are conducted using infrastructures to access hardware performance counters. Most modern processors provide such counters to count micro-architectural events such as retired instructions or clock cycles. These counters can be diffocult to configure, may not be programmable or readable from user-level code, and can not discriminate between events caused by different software threads. Various software infrastructures address this problem, providing access to per-thread counters from application code. This paper constitutes the first comparative study of the accuracy of three commonly used measurement infrastructures (perfctr, perfmon2, and PAPI) on three common processors (Pentium D, Core 2 Duo, and AMD ATHLON 64 X2). We find significant differences in accuracy of various usage patterns for the different infrastructures and processors. Based on these results we provide guidelines for finding the best measurement approach